Process execution management based on resource requirements and business impacts

ABSTRACT

Techniques are presented for managing execution of processes on a data processing system. The data processing system comprises process instances that are each an execution of a corresponding process. Each process instance comprises activity instances. Business impacts are determined for the process instances, the activity instances, or both. Order of execution of the activity instances is managed by allocating resources to activity instances in order to achieve an objective defined in terms of the business impacts. In another embodiment, requests are received for the execution of the processes. For a given request, one or more of the operations of assigning, updating, aggregating, and weighting of first business impacts associated with the given request are performed to create second business impacts associated with the given request. Additionally, requests can be modified. Modification can include changing the process requested or process input as deemed appropriate, combining related requests into a single request, or both. Unmodified requests and any modified requests are managed.

FIELD OF THE INVENTION

The present invention relates generally to the field of WorkflowManagement Systems (WFMSs), and relates, in particular, to controllingthe order of activity execution in a WFMS based upon resourcerequirements and impact to the business.

BACKGROUND OF THE INVENTION

A workflow process (called a “process” herein) is a directed, acyclicgraph of activities to be performed. In general, an activity is a unitof work to be performed by, for instance, a human or a software agent; ablock of activities which can be repeated until some condition isreached; or another process. Between activities are links, possiblyconditional, which are evaluated at runtime to determine an executionpath. Data can also be passed between activities or made globallyavailable to all activities.

Because a process is a graph of activities to be conditionallyperformed, a process is considered to be a model (i.e., a template) forthe execution of the activities. An execution of a process is referredto as a process instance. The representation of an activity within aprocess is performed by an activity instance. If and in what order theactivity instances within a process instance are readied for executionis determined by the links between activity instances in the processmodel. An activity instance which is ready to be executed can be queuedin one or more work lists, each of which is associated with a human orsoftware agent which can perform the activity, and is commonly referredto as a work item. In the scheduling domain, a job is equivalent to aprocess instance, and a task is equivalent to an activity instance or awork item.

A Workflow Management System (WFMS) enables the modeling and executionof processes. A WFMS facilitates codification, automation, composition,and lifecycle management of business system support (BSS) and operationssystem support (OSS) processes. IBM WebSphere MQ Workflow is an exampleof a WFMS. Workflow management is also emerging as an importantapplication execution management technology, particularly in the area ofgrid and utility computing, where planned application executionsequences are essentially managed and composed as automated workflows.The ability to manage the execution of processes is valuable across themany domains where workflow is employed. Some examples of processeswhich can benefit from process execution management are semi-automatedloan approval workflows, Information Technology (IT) operationsmanagement workflows (e.g., provisioning of servers), and softwareapplication job execution workflows.

Illustratively, consider a business which offers its customers a numberof services with guaranteed levels of service level and associatedrefund and rewards. For example, the business may offer a storageservice with a service level guarantee that, over the course of a month,97 percent of customer requests for additional storage will beprovisioned within two hours. If the business fails to meet thiscommitment, a penalty, which is a percentage of the monthly service fee,will be refunded to the customer. The penalty could be defined as a stepfunction which increases as the percentage of customer requestscompleted within the threshold of two hours decreases. The businessoffers several different classes of storage (e.g., economy, fast, andsuper-fast) with different service level guarantees (e.g., in terms oftarget percentage and threshold time) at appropriate prices withdifferent refunds and rewards. The refunds and rewards which thebusiness offers to its customer represent an actual financial impact tothe business as well as an objective measure of value to the customer.

The business has an obligation to meet its commitments and needs to doso in a cost effective and efficient manner if it is to remain viableand competitive. Therefore, when the business executes its processes(e.g., responding to customer requests for additional storage), thebusiness needs to manage its resources (e.g., people and computingservers) in a manner consistent with the business commitments (e.g.,service quality defined as service levels) and cost and efficiencyobjectives of the business (e.g., to minimize penalties). Current WFMSsready activity instances for execution based on conditions andnavigation defined by the processes, but no explicit consideration isgiven to objectives or commitments of businesses.

What is needed then are techniques for enabling an organization tomanage process execution in a manner which meets its commitments whilealso meeting its cost and efficiency objectives.

SUMMARY OF THE INVENTION

The present invention provides techniques for managing the execution ofprocesses. Using the present invention allows an organization to meetits commitments while also meeting its cost and efficiency objectives.

In an exemplary aspect of the invention, techniques are presented formanaging execution of processes on a data processing system. The dataprocessing system comprises one or more process instances that are eachan execution of a corresponding process. Each process instance comprisesone or more activity instances. In this exemplary aspect, one or morebusiness impacts are determined for the one or more process instances,the one or more activity instances, or both the one or more processinstances and the one or more activity instances. The order of executionof the activity instances is managed by allocating resources to activityinstances in order to achieve an objective defined in terms of the oneor more business impacts.

In another exemplary aspect of the invention, techniques are presentedfor managing requests for execution of one or more processes on a dataprocessing system. One or more requests are received for the executionof the one or more processes. For at least a given one of the one ormore requests, one or more of the operations of assigning, updating,aggregating, and weighting of one or more first business impactsassociated with the given request are performed to create one or moresecond business impacts associated with the given request. The givenrequest is for execution of a given process. A given request is modifiedto create a modified request. The modified request is for execution ofthe given process or another process. Unmodified requests and anymodified requests are managed in order to execute processescorresponding to the unmodified and modified requests.

A more complete understanding of the present invention, as well asfurther features and advantages of the present invention, will beobtained by reference to the following detailed description anddrawings.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a representation of a data processing system in which thepresent invention may be implemented;

FIG. 2 is a block diagram is shown of a data processing system in whichthe present invention may be implemented;

FIG. 3 is an illustrative high level block diagram of an exemplaryprocess execution manager within an organization;

FIG. 4 is a high level block diagram of an exemplary process executionmanager but in a cross organizational environment;

FIG. 5 is a block diagram of more detailed view of an exemplary processexecution manager;

FIG. 6 is a use case diagram depicting potential uses of a processexecution manager controller of an exemplary embodiment of the presentinvention;

FIG. 7 is a class diagram for an illustrative framework suitable forimplementing a process execution manager in accordance with an exemplaryembodiment of the present invention;

FIG. 8 is a flowchart of a method for the initialization of a moduleillustratively referred to as the ProcessExecutionManagerController, inaccordance with an exemplary embodiment of the present invention;

FIG. 9 is a flowchart of a method for importing a process, in accordancewith an exemplary embodiment of the present invention;

FIG. 10 is a flowchart of a method for suspending a resource inaccordance with an exemplary embodiment of the present invention;

FIG. 11 is a flowchart of a method for resuming a resource in accordancewith an exemplary embodiment of the present invention;

FIG. 12 is a flowchart of a method for updating the business impacts fora process instance and its activity instances, in accordance with anexemplary embodiment of the present invention;

FIG. 13 is a flowchart of a method for starting a process instance, inaccordance with an exemplary embodiment of the present invention;

FIG. 14 is a flowchart of a method for canceling a process instance inaccordance with an exemplary embodiment of the present invention;

FIG. 15 is a flowchart of a method for suspending an activity instancein accordance with an exemplary embodiment of the present invention;

FIG. 16 is a flowchart of a method for resuming an activity instance, inaccordance with an exemplary embodiment of the present invention;

FIG. 17 is a flowchart of a method for querying a process instance, inaccordance with an exemplary embodiment of the present invention;

FIG. 18 is a flowchart of a method for requesting a restart of ascheduling system, in accordance with an exemplary embodiment of thepresent invention;

FIG. 19 is a flowchart of a method for querying resource information inaccordance with an exemplary embodiment of the present invention;

FIG. 20 is a flowchart of a method for starting a task, in accordancewith an exemplary embodiment of the present invention;

FIG. 21 is a flowchart of a method for updating resource information inaccordance with an exemplary embodiment of the present invention;

FIG. 22 is a flowchart of a method for requesting a refresh of theresource information, in accordance with an exemplary embodiment of thepresent invention;

FIG. 23 is a flowchart of a method for handling an override to aschedule, in accordance with an exemplary embodiment of the presentinvention; and

FIG. 24 is a flowchart of a method for requesting handling of a workflowevent in accordance with an exemplary embodiment of the presentinvention.

DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS

In conventional Workflow Management Systems (WFMSs), a single resource(generally a person or a software agent) is required to perform anactivity instance. The WFMS may assign an activity instance to anynumber of resources which can perform the activity. Eventually, oneresource will execute the activity instance using implementation codeassociated with the activity. At any point in time, a resource may havemultiple activity instances which are deemed “ready to execute” assignedto the resource Which of the ready activity instances and in which orderthe resource executes these activity instances is generally not dictatedby conventional WFMSs. The order is rather left to human intuition orexperience, a static priority scheme, or first-come-first-servedqueuing. Also, if any additional resources (e.g., a software license)are required for execution of an activity instance, it is theresponsibility of the activity implementation code, and not theresponsibility of the WFMS, to discover, reserve, and obtain thoseresources.

The present invention can solve these problems by, in an exemplaryembodiment, managing the order of activity execution by assigningconstrained resources required for execution based on an overallobjective defined in terms of one or more business impacts. This isaccomplished by, illustratively, integrating one or more WFMSs orequivalents, one or more scheduling systems, and one or more resourcemanagers using a process execution manager controller and one or morebusiness impact integrators. Additionally, requirements for multipleresources per activity instance can be managed. The scheduling systemdetermines when an activity instance requiring constrained resources anddeemed “ready to execute” by the WFMS should start and which resourceswill be assigned to the activity instance. This managing action ofstarting a task is made, in an exemplary embodiment, in a just-in-timemanner so that the scheduling system can accommodate dynamic changes inthe system (e.g., newly arriving jobs or changes in business impact foran existing process instance). As a result, a resource (e.g., a human orsoftware agent) typically has only one assignment at a given time (i.e.,only one work item in its work list).

A business impact is associated with the execution of a process instanceor activity instance or both. A business impact is a measure of relativeimportance (e.g., defined through a value) that timely execution of aninstance (e.g., process or activity instance) will have on theorganization. For example, a business may want to execute its processesin a manner which minimizes penalties associated with failure to meet aguaranteed level of service. Thus, the business impact could be thevalues (e.g., defined as a step function) for penalties associated withnot meeting guaranteed levels of service. The overall objective in thisscenario is to minimize penalties. The business impact can also includean objective function or pointer to an objective function which could beused by the scheduling system controller when the scheduling systemperforms an objective optimization.

A business impact can be pre-defined or obtained dynamically at runtime.The business impact can be, but is not limited to, one or more of asimple priority, a utility function, or a cost function over time.Additionally, the business impact can be modified over the duration ofthe process instance, activity instance, or both process and activityinstances.

In certain embodiments of the present invention, a resource is an entity(such as a person, a software agent, hardware, or a software license)required for an activity to be performed. In general, exemplaryembodiments of present invention enable an organization to ensure thatjobs with a high business impact and a tight deadline will be allocatedresources in preference to those jobs with a lower business impact, amore flexible deadline, or both a lower business impact and a moreflexible deadline.

Certain embodiments of the present invention are able to address processmodels ranging from simple task lists to complex task graphs.Illustratively, a process can be fully automated or be partiallyautomated (i.e., contain manual tasks performed by humans). Embodimentsof the present invention can also be applied to processes which crossorganization boundaries, that is, processes which contain activitieswhich are performed by another organization. The extent to which one canmanage resources outside of an organization will depend on the abilityto monitor those resources, the extent of control allowed by the owningorganization, or both.

For sake of clarity, it is assumed that the term “instance” relates to aprocess instance or an activity instance. It is also assumed that a“business” is any entity using a WFMS or equivalent, and the terms“organization” and “business” are interchangeable.

Exemplary embodiments of the present invention enable an organization,through a data processing system having a process execution manager, toperform one or more of the following:

(1) associate business impact with instances, where the business impactcan be modified throughout the duration of the instances;

(2) capture metadata about processes, where the metadata can be used forscheduling purposes;

(3) manage the order of execution of instances based on the assignmentof constrained resources to instances using one or more of the following(although typically all would be used) which could reside on differentdata processing systems: (A) one or more WFMSs or systems withcomparable functions to define the process models and execute theprocess instances, (B) one or more scheduling systems to order executionof instances by assigning resources to instances in a manner whichachieves an objective defined in terms of the business impactsassociated with the instances, and (C) one or more resource managers toprovide resource information required by the scheduling system orsystems selected;

(4) integrate existing WFMSs, scheduling systems, and resource managersvia adapters;

(5) extend the definitions of key data (e.g., business impact, resource,override, and task duration) and the functions provided in order tosupport the requirements of a given environment (e.g., the organizationand the selected scheduling systems, workflow systems, and resourcemanagers);

(6) override resource assignments made by the scheduling system(s) asneeded;

(7) transform, if possible, a workflow model of a WFMS to one supportedby one or more selected scheduling systems;

(8) assign default business impacts, including objective functions, asneeded and weight business impacts as required by the organization;

(9) combine individual “related” requests with associated businessimpacts into a single request with an aggregated business impact; and

(10) modify (e.g., alter or combine) requests for process execution, themodification performed for cost and efficiency purposes, the cost andefficiency determined by one or more criteria set by the organization.

An exemplary embodiment of the present invention describes a method formanaging the execution of process instances in one or more existingWFMSs or systems with comparable functionality. Those skilled in the artwill recognize that much of the functionality of this invention couldalso be incorporated into the design of future WFMSs.

According to various exemplary embodiments of the present invention, andas previously described, techniques are provided to manage requests forprocess execution and to order the execution of activity instances inthe process instances in one or more WFMSs. An exemplary goal of thepresent invention is to achieve some objective defined by theorganization in terms of the business impacts associated with theexecution of instances. For example, an organization can associate apenalty function with the completion of each process instance and use ascheduling system which would assign resources such that the overallpenalty incurred is minimized.

Design elements of an exemplary framework, which can be used toimplement an illustrative embodiment of the present invention, caninclude one or more of the following:

(1) the framework should support multiple and arbitrary WFMSs providedthe WFMSs offer the ability to monitor progress at the activity instancelevel and control the start of an activity instance;

(2) the framework should support multiple and arbitrary schedulingsystems;

(3) the framework should support multiple and arbitrary resourcemanagers;

(4) the framework should support multiple business impact integrators;

(5) the framework should, to the extent possible, support transformationof a workflow model to one supported by a particular scheduling system;

(6) the framework should provide core functionality generally supportedby WFMSs and extensible functionality for those functions likely to varyby environment;

(7) an assumption may be made that the WFMSs will maintain the currentstate and history of workflow executions, that the resource managerswill maintain the availability and required skill information, and thatthe scheduling system maintains no persistent data;

(8) the framework can use a store associated with each business impactintegrator for maintaining information about the process requests,possible aggregations of requests, possible modifications of requests,and their associated business impacts and aggregations; and

(9) the framework can use a store for maintaining information onbusiness impacts associated with process instances, process modelinformation, and override information.

With reference now to the figures and in particular with reference toFIG. 1, a pictorial representation of a computer system 100 in which thepresent invention may be implemented is depicted in accordance with anexemplary embodiment of the present invention. A computer system 100 isdepicted which includes system unit 102, video display terminal 104,keyboard 106, storage devices 108, which may include floppy drives andother types of permanent and removable storage media, and mouse 110.Additional input devices may be included with computer system 100, suchas, for example, a joystick, touchpad, touch screen, trackball,microphone, and the like. Computer system 100 can be implemented usingany suitable computer. Although the depicted representation shows acomputer, other embodiments of the present invention may be implementedin other types of data processing systems, such as a network computer.Computer system 100 also preferably includes a graphical user interface(GUI) that may be implemented by means of systems software residing incomputer readable media in operation within computer system 100.

With reference now to FIG. 2, a block diagram of a data processingsystem 200 is shown in which embodiments of present invention may beimplemented. Data processing system 200 is an example of a computersystem, such as computer system 100 in FIG. 1, in which code orinstructions implementing the processes of the present invention may belocated. Data processing system 200 employs a Peripheral ComponentInterconnect (PCI) local bus architecture. Although the depicted exampleemploys a PCI bus, other bus architectures such as Accelerated GraphicsPort (AGP) and Industry Standard Architecture (ISA) may be used.Processor 202 and main memory 204 are connected to PCI local bus 206through PCI bridge 208. PCI bridge 208 also may include an integratedmemory controller and cache memory for processor 202. Additionalconnections to PCI local bus 206 may be made through direct componentinterconnection or through add-in boards.

In the depicted example, Local Area Network (LAN) adapter 210, smallcomputer system interface SCSI host bus adapter 212, and expansion businterface 214 are connected to PCI local bus 206 by direct componentconnection. In contrast, audio adapter 216, graphics adapter 218, andaudio/video adapter 219 are connected to PCI local bus 206 by add-inboards inserted into expansion slots. Expansion bus interface 214provides a connection for a keyboard and mouse adapter 220, modem 222,and additional memory 224. SCSI host bus adapter 212 provides aconnection for hard disk drive 226, tape drive 228, and CD-ROM drive230. Typical PCI local bus implementations will support three or fourPCI expansion slots or add-in connectors.

An operating system (not shown) runs on processor 202 and is used tocoordinate and provide control of various components within dataprocessing system 200 in FIG. 2. The operating system may be acommercially available operating system such as Windows XP, which isavailable from Microsoft Corporation. An object oriented programmingsystem such as Java may run in conjunction with the operating system andprovides calls to the operating system from Java programs orapplications executing on data processing system 200. “Java” is atrademark of Sun Microsystems, Inc. Instructions (e.g.,computer-readable code) for the operating system, the object-orientedprogramming system, and applications or programs are located on storagedevices, such as hard disk drive 226, and may be loaded into main memory204 for execution by processor 202.

As is known in the art, the methods and apparatus described herein maybe distributed as an article of manufacture that itself comprises acomputer-readable medium having computer readable program code meansembodied thereon. For instance, the computer-readable medium could bedisk 226, tape 228, or CD-ROM 230. The computer readable program codemeans is operable, in conjunction with data processing system 200, tocarry out all or some of the steps to perform the methods or create theapparatuses discussed herein.

Further, those of ordinary skill in the art will appreciate that thehardware in FIG. 2 may vary depending on the implementation. Otherinternal hardware or peripheral devices, such as flash read-only memory(ROM), equivalent nonvolatile memory, or optical disk drives and thelike, may be used in addition to or in place of the hardware depicted inFIG. 2. Also, the processes of the present invention may be applied to amultiprocessor data processing system.

For example, data processing system 200, if optionally configured as anetwork computer, may not include SCSI host bus adapter 212, hard diskdrive 226, tape drive 228, and CD-ROM 230. In that case, the computer,to be properly called a client computer, includes some type of networkcommunication interface, such as LAN adapter 210, modem 222, or thelike. As another example, data processing system 200 may be astand-alone system configured to be bootable without relying on sometype of network communication interface, whether or not data processingsystem 200 comprises some type of network communication interface. As afurther example, data processing system 200 may be a personal digitalassistant (PDA), which is configured with non-volatile memory, such asflash ROM, to provide for storing operating system files, user-generateddata, or both.

The depicted example in FIG. 2 and above-described examples are notmeant to imply architectural limitations. For example, data processingsystem 200 also may be a notebook computer or hand held computer inaddition to taking the form of a PDA. Data processing system 200 alsomay be a kiosk or a Web appliance. The processes of the presentinvention are performed by processor 202 using computer implementedinstructions, which may be located in a memory such as, for example,main memory 204, memory 224, or in one or more peripheral devices226-230.

An exemplary embodiment of the present invention is represented in thehigh level block diagram of FIG. 3, which depicts a process executionmanager 390. It should be noted that a process execution manager 390 canbe implemented on a distributed computer system comprised on many dataprocessing systems. The process execution manager 390 depicts theprocess execution manager controller 307 interacting with one or morescheduling systems 305, resource managers 306, and WFMSs 308. FIG. 3also shows that requests 300 for execution of processes can be sent to abusiness impact integrator 301 which, in an exemplary embodiment, can(1) assign a default business impact; (2) weight the business impact;(3) combine related requests 300 and aggregate, weight, or both theirbusiness impacts; (4) alter individual or combined requests 300; or (5)perform a combination of (1)-(4) to improve cost and efficiency of theexecution of instances, which should improve cost and efficiency for thebusiness. The improvement in cost and efficiency of execution ofinstances may be determined by one or more criteria set by theorganization. In other words, the organization itself typicallydetermines how “cost” and “efficiency” are defined, such as fasterresponse time or lower cost. It should be noted that not all requests300 need have an associated business impact. Nonetheless, the capabilityto combine related requests 300 is useful for those environments wheremultiple requests 300 for the same process execution are received andshould be filtered.

For example, several requests 300 to start a server can be satisfiedwith a single process execution. The business impact integrator 301should implement one or more procedures (e.g., algorithms, methods, orfunctions) for determining if two requests are related and how theyshould be combined. An organization typically defines the one or moreprocedures used to combine requests 300. The capability to alterrequests is useful for cost and efficiency purposes (e.g., defined by anorganization and can include cost or time). For example, a request 300for executing a process may be altered to use another process which willaccomplish the same goal more efficiently. The business impactintegrator 301 could also combine and alter requests 300 for processexecution. For example, the business impact integrator 301 may receivemultiple requests 300 for additional storage, where the multiplerequests could be combined into another request 300, with an aggregatedbusiness impact, where the other request 300 would perform (e.g.,through execution of a corresponding process) all the additions forstorage in a more cost effective manner. The cost effectiveness can bedetermined in any number of ways, including execution time of theprocess. The business impact integrator 301 should have the data andmethods implemented to provide this combining function. It should benoted that a given request 300 will have associated with the request 300a goal.

In an exemplary embodiment of the present invention, as depicted in FIG.3, there can be multiple business impact integrators 301. A processexecution request 302 along with an associated business impact can besent to one of the business impact integrators. Alternatively, theprocess execution request 302 can be sent directly to the processexecution manager controller 307. In addition, a request 304 to executeprocess instances can be sent to the WFMS 308 directly. In this case,the associated business impact 303 for the process instance should besent to or otherwise obtained or determined by the process executionmanager controller 307.

The process execution manager controller 307 is used to allowembodiments of the present invention to manage process execution throughresource allocation based on business impacts. The business impactintegrator 301 may be used to allow embodiments of the present inventionto manage requests for process execution and their associated businessimpacts. The process execution manager controller 307, in particular,interacts with and provides a framework for the scheduling systems 305,resource managers 306, and the WFMSs 308 to manage process execution.The techniques and data stores for the business impact integrator 301and the process execution manager controller 307 can be implemented inother entities, such as a WFMS 308.

A role of the scheduling system 305 is to determine which tasks (i.e.,activity instances) of those that have been deemed “ready to execute” bythe WFMS 308 to start in order to use the required constrained resourcesin a manner which optimizes the objective function, defined in terms ofbusiness impact, of the organization. The process execution managercontroller 307 provides the scheduling systems 305 with information onresources (e.g., availability, cost, and capability), process modelinformation, current process execution status, and business impactassociated with specific process and activity instances. A conventionalscheduling system might assign resources in such a manner as to maximizethroughput. By contrast, a scheduling system in an exemplary embodimentof the present invention would use its objective optimizer 312 to assignresources in a manner which achieves a business objective defined interms of business impact (e.g. minimize penalty) and in a just-in-timefashion so as to take into account any dynamic changes in the system(e.g., a newly arrived job, updates to business impact of an existingjobs, etc.).

FIG. 4 illustrates an example of how the process execution manager 400as depicted in FIG. 3 can be used to manage process instances 401 whichcross the organization's boundaries. The process execution manager 400can use information collected either from monitoring the externalresources, e.g., Application C₁ 402 executing in external Organization C403 or Application B₃ 404 executing in external Organization B 405, orobtained (e.g., possibly dynamically) from the organization owning theexternal resource, e.g., external Organization C 403 or externalOrganization B 405. Such information can be used by the framework tocontrol the assignment of activities to external resources, where theexternal resource is to perform the activity. In the example of FIG. 4,application 402 is owned by Organization C 403, but Organization C 403does not own the process execution manager 400 (e.g., a data processingsystem that implements the process execution manager 400).

FIG. 5 is a block diagram of a more detailed view of an exemplaryprocess execution manager 590. The process execution manager 590comprises one or more scheduling systems 500, one or more resourcemanagers 504, one or more business impact integrators 508, a processexecution manager controller 510, and one or more WFMSs 515. Eachscheduling system 500 comprises a model transformer 503 which interactswith a scheduling system adapter 502 which in turn interacts with ascheduling system controller 501. The scheduling system controller 501comprises an objective optimizer 582 which is used to assign resourcesto activity instances in a manner which optimizes an objective. Theprocess execution manager controller 510 interacts with the modeltransformer 503 for a scheduling system 500. A model transformer 503 maybe used as an interface between a scheduling system 500 and another partof the process execution manager 590. For example, the WFMS 515 mightsupport complex process models but the scheduling system 500 supportsimple process models. The model transformer 503 could then, to theextent possible, transform information about the complex process modelsinto information suitable for use by the scheduling system 500.

For each resource manager 504, the process execution manager controller510 interacts with a resource adapter 507 which in turn interacts with aresource manager controller 505. Similarly, for each WFMS 515, theprocess execution manager controller 510 interacts with a workflowsystem adapter 516 which in turn interacts with a WFMS controller 517.The process execution manager controller 510 also creates a monitor 513for each WFMS 515 for tracking progress of process instances in the WFMS515. The Application Programming Interface (API) methods 521, 526, 531,541, 546, 551, 556, 561, 566, and 571 are defined for each of theinteractions 520, 525, 530, 540, 545, 550, 555, 560, 565, and 570,respectively.

Requests regarding process instances (e.g., startProcesslnstance in API521) can be sent to the process execution manager controller 510directly or through the business impact integrator 508. As previouslydescribed, the business impact integrator 508 can be used to add adefault business impact or can weight or otherwise modify the businessimpacts associated with a process instance request. Additionally, thebusiness impact integrator 508 can combine related process instancerequests into a single request and aggregate, weight, or both associatedbusiness impacts into a single business impact. The business impactintegrator 508 can also alter the process requested to a process whichis more efficient (e.g., cost effective or timely) for an organization.The business impact integrator 508 can also combine and alter processinstance requests into a single request for execution of anotherprocess, where the other process is more efficient for the business. Thebusiness impact integrator 508 maintains a store 509 of processrequests, associated business impacts, and any combinations andalterations made.

The resource manager 504 (note that there may be multiple resourcemanagers 504) is expected to maintain resource information required forscheduling (e.g., skills and schedules) in a store 506. The WFMS 517(note that there may be multiple WMFSs 517) is expected to maintaininformation of processes and process instances in stores 518 and 519.The process execution manager controller 510 maintains a store 512 forinformation for configuration 512, a store 511 for process instances andtheir associated business impacts, and a store 514 for processes andscheduling overrides 514. A scheduling override overrides an assignmentfor a resource. For example, a manager may have a reason for wanting aparticular employee to perform an activity for a particular processinstance and therefore may choose to override the assignment by thescheduling system of that activity to another employee.

Use cases for a process execution manager controller 601, such as theprocess execution manager controller 510 in FIG. 5, are illustrated inFIG. 6. The actors (e.g., humans, systems, and software agents) andtheir associated tasks are as follows:

(1) System administrator 605: initializes the process execution manager(step 606-1); imports a process template (step 606-2); suspends anactivity instance (step 606-3); and resumes an activity instance (step606-4).

(2) Activity assignee 610: suspends assignments to himself or herself(step 611-1); and resumes assignments to himself or herself (step611-2).

(3) Business impact assigner 615: associates or updates a businessimpact with an instance (step 616).

(4) Business impact requester plus a business impact assigner (e.g., abusiness impact integrator) 620: associates or updates a business impactwith a process instance (step 616); queries status of a process instance(step 621-1); creates or starts the execution of a process (step 621-2);and cancels a process instance (step 621-3).

(5) Process Requestor 625: creates and starts, cancels, and suspends aprocess instance (step 626) directly in the WFMS 630.

(6) Scheduling system 640: requests a refresh of all requiredinformation (step 641-1); queries about some or all resources (step641-2); starts a task by assigning resource(s) to the task (e.g.,possibly preempting other assignments) (step 641-3): and updatesinformation about selected resource(s) (step 641-4).

(7) Resource manager 635: refreshes information for some or allresources (step 636-1); and overrides an assignment of resource(s) by ascheduling system to a task (step 636-2).

(8) WFMS 630: updates the progress of an instance (step 631).

FIG. 7 illustrates an exemplary class diagram 700 for a frameworksuitable for implementing a process execution manager including aprocess execution manager controller 307, 510, or 601 and a businessimpact aggregator 301 or 506. The main class is theProcessExecutionManagerController 705. An instance of theProcessExecutionManagerController is a process execution managercontroller and contains a list of:

(1) resource managers (resManagers 707, instances of ResourceManager716);

(2) WFMSs managers (wfSystems 708, instances of WFSystem 717);

(3) scheduling systems managers (schedulers 709, instances of SchSystem718);

(4) processes (processes 710, instances of Process 715);

(5) unique mappings between the process instance identifications (IDs)in the WFMSs and job IDs in the scheduling system (jobMap 712, instancesof JobIDMap 720); and

(6) unique mappings between the workflow resource IDs in the workflowsystems and the resource IDs in the scheduling systems (resMap 711,instances of ResIDMap 719).

A process 715 contains a list of activities (activities 721, instancesof Activity 722) and a list of links (links 724, an instance of Link725) between activities. Each activity instance contains a duration(Duration 723). An impact (Impact 726) can be associated with a processinstance or an activity instance. Each ResourceManager (resManagers 707,instances of ResourceManager 716) contains a resource adapter (adapter727, an instance of ResAdapter 728) which implements theResourceManagerAdapter interface 752 and is used by theProcessExecutionManagerController 705 to interact with the resourcemanager (ResourceManager 716). Each workflow system manager instance(wfSystems 708, instances of WFSystem 717) contains the name of aworkflow adapter (adapter 730, and instance of WFAdapter 731) whichimplements the WFSystemAdapter interface 753 and is used by theProcessExecutionManagerController 705 to interact with the workflowsystem manager and a monitor (monitor 732, an instance of Monitor 733)which is used to monitor progress in the WFMS (e.g., 708).

Each scheduling system manager (schedulers 709, instances of SchSystem718) contains the name of a model transformer (modelTransformer 735, aninstance of ModelTransformer 736) and a scheduling system adapter(adapter 750, an instance of SchAdapter 751). TheProcessExecutionManagerController 705 interacts with the modeltransformer (e.g., 736) which in turn interacts with the schedulingsystem adapter (e.g., 751). The SchedulingSystemAdapter class 760defines a programming interface which should be supported by anyscheduling system adapter integrated with the ProcessExecutionManagerframework 700. The WFModelTransformer class 780 defines a programminginterface which should be supported by any model transformer integratedwith the ProcessExecutionManager framework 700.

Each scheduling system manager (schedulers 709, instances of SchSystem718) also contains a list of jobs (jobs 737, instantiated from Job 738),resources (res 743, instantiated from Resource 744), overrides(overrides 741, instantiated from Override 742), commonalities(commonalities 745, instantiated from Commonality 746), andsimultaneities (simultaneities 739, instantiated from Simultaneity 740)which the scheduling system manager (schedulers 709, instances ofSchSystem 718) uses for scheduling purposes. Each job 738 may contain abusiness impact (Impact 766), a list of tasks (tasks 761, instantiatedfrom Task 762), and a list of links between tasks (links 763,instantiated from Link 764). Each task (Task 762) contains a duration(Duration 765) and optionally a business impact (Impact 766).

The framework 700 also contains a class for a business impact integrator770 which is used to aggregate related requests for the execution of aprocess into a single request and to aggregate, weight, or bothassociated business impacts for the similar requests into a singlebusiness impact (e.g., associated then with the single request). Thebusiness impact integrator 770 can also be used to assign defaultbusiness impacts to requests for the execution of a process or to weightrequests for some business purpose (e.g., to give preference to acertain types of requests or to requests from particular customers).Additionally, a business impact integrator 770 can be used to alterrequest for process execution, individual or combined, to a request foranother process with aggregated business impact for cost and efficiencypurposes.

Classes are also specified for a ResourceEvent 776, a WorkflowEvent 777and a generalized Event 775. These are used to inform theProcessExecutionManagerController 705 and SchSystem 718 of events (e.g.,Event 775) regarding resource changes (e.g., ResourceEvent 776) orworkflow progress (WorkflowEvent 705).

FIGS. 8-24 are high level flow diagrams for each of the use cases inFIG. 6. Each figure shows a method and each method has an illustrativeassigned name in pseudocode. During the description of FIGS. 8-24,please refer to FIGS. 5 and 7 also.

With reference to FIG. 8, the initialization of a module illustrativelyreferred to as the ProcessExecutionManagerController (e.g.,ProcessExecutionManagerController 705, which will be assumed during theupcoming description) is shown in accordance with an exemplaryembodiment of the present invention. The method 890 shown in FIG. 8 maybe illustratively named, in pseudocode, as PEMC.init( ). Wheninitialized, the ProcessExecutionManagerController 705 will readconfiguration data in the persistent store (e.g., configuration store512 of FIG. 5). This occurs in step 800. In step 801, theProcessExecutionManagerController 705 will create a list of schedulingsystems (e.g., schedulers 709) to be supported including the adapter(e.g., adapter 730) and model transformer (e.g., modelTransformer 735)to be used for each scheduling system. In step 802, a list of WFMSs(e.g., wfSystems 708) is created including the appropriate adapter to beused for each workflow system. In step 803, a list of resource managers(e.g., resManagers 707) is created including the adapter to be used foreach resource manager. In step 804, an empty list of processes (e.g.,processes 710) currently being managed is created. A map (e.g., jobMap712) of scheduling system job IDs to workflow system job IDs is createdfrom information in the store (e.g., Process Instances+Impacts store 511of FIG. 5). This occurs in step 805.

In steps 806-812, a list of resource IDs along with an associatedscheduler IDs and workflow resource IDs which are to be managed by eachscheduling system is determined from the resource manager (e.g.,resManagers 707). Step 806 (“for each resource manager resManagers[i]”)begins a loop that ends in step 812. In step 807, the list of resourceIDs, associated scheduler ID and workflow resource ID information isadded to the resource map (e.g., ResMap 711) maintained by theProcessExecutionManagerController 705. In step 807, the pseudocode fordetermining a list of resources associated with schedulers and workflowresource IDs is res=resManagers[i].adapter.getResources. In step 808,the resource IDs are added to resMap 711 along with a matching ID in theWFMS. The resource information is added to each of the appropriateschedulers in steps 809-811. Step 809 starts a loop (“for eachscheduler, schedulers[j]”) that ends in step 811. In step 810, resourcesin res which are scheduled by the currently selected scheduler (e.g.,schedulers 709) are added to schedulers[j].res.

Step 813 starts a loop ended in step 826. For each WFMS (e.g., “for eachwf system wfSystems[i]” in step 813) steps 814-825 are performed. Instep 814, a timestamp is determined for a last event recorded in anaudit trail (e.g., “get end date of recorded audit trail,auditDate=wfSystem[i].adapter.getAuditAsOf( )” in step 814). In step815, a list is determined of currently active jobs process instances(e.g., “get info on running jobs,jobs=wfSystem[i].adapter.getStatus(auditDate)” in step 815).

In step 816, a map (e.g., jobMap 712) is updated as needed, where themap is of scheduling system job IDs to workflow system process instanceIDs. In step 817, any newly encountered processes are added to the listof processes (e.g., processes 710). Step 818 starts a loop for each job,jobs[j], and this loop ends in step 823. Step 819 starts a loop for eachscheduler, schedulers[j], and this loop ends in step 822. Thus, for eachjob in steps 818-823 and each scheduler in steps 819-822, if the jobrequires resources managed by the scheduler (step 820, written as“jobs[j] uses resources in scheduler[i].res?” in FIG. 8), information onthe job is added to the scheduler (step 821, written as “add jobs[j], toschedulers[i]jobs” in FIG. 8).

In step 824, a monitor for this WFMS (e.g., “create a monitorwfSystem[i].adapter.mon”), and progress is monitored in step 825 (e.g.,“Start monitoringwfSystem[i].adapter.mon.monitorProgress( )”. Finally,step 827 starts a loop performed for each scheduler, schedulers[i], thatends in step 830. For each scheduler, get a list of overrides from thestore (e.g., store 514 of FIG. 5) for resources and jobs managed by thisscheduler (step 828). Additionally, the scheduler is initialized withthe jobs, resources, and override information, written in pseudocode asthe following: schedulers[i].modelTransformer.init (schedulers[i].jobs,schedulers[i].res, scheduler[i].overrides)”). Method 890 ends after step830.

With reference to FIG. 9, a method 990 for importing a process isillustrated in accordance with an exemplary embodiment of the presentinvention. In pseudocode, the method 890 shown in FIG. 9 may beillustratively named PEMC.importProcess (wfs, pID, validFrom,inputClass). The input parameters specify the WFMS, the process ID, the“valid from” date (e.g., used to differentiate versions of a process),and the name of a class which is used to prepare input for the executionof this process (e.g., defined by the process ID). Method 990 is used toimport process information required by theProcessExecutionManagerController 705 as well as metadata required byone or more schedulers into the store for (e.g., Processes store 514 ofFIG. 5).

The first step (step 900) of method 990 is to match the WFMS specifiedwith one of those supported (shown as “determine wfSystems[i] forspecified workflow system wfs” in step 900 of FIG. 9). In step 901, theworkflow adapter for this WFMS is invoked to load the basic processinformation needed by the ProcessExecutionManagerController 705. This isdescribed as “invoke wfSystems[i].adapter.importProcess (pID, validFrom)to get process details from wfs or elsewhere if necessary” in step 901of FIG. 9. Metadata about the new process is stored in a store (e.g.,store 514 of FIG. 5) in step 502, written as “record information aboutthe new process wfs, pid, validFrom, inputClass, etc. in permanentstore.” In step 903, a zero (e.g., successful) or one (e.g.,unsuccessful) is returned to a requester if the update was successful orwas not successful, respectively. Method 990 ends after step 903.

With reference to FIG. 10, a method 1090 for suspending a resource isillustrated in accordance with an exemplary embodiment of the presentinvention. The method 1090 shown in FIG. 10 may be illustratively namedin pseudocode as PEMC.suspendResource (wfs, wfRresID, duration, flag).The input parameters specify the WFMS, the workflow resource ID, aduration during which the resource will not be available and a flagindicating how the current assignment, if any, is to be handled (e.g.,allow resource to complete the current assignment before beginningsuspension, re-assign the current assignment to another resource, orhold this assignment for this resource). The method 1090 is intended toallow a human resource to inform the scheduler of an unscheduled periodof unavailability.

The first step (step 1000) in method 1090 is to match the WFMS specifiedwith of those supported, which is a step of determining a wfSystems[i]for a specified WFMS, wfs. In step 1001, the appropriate resource ID isobtained for the specified workflow resource ID (e.g., “get resID forthis wfs and wfResID”). Step 1002 starts a loop performed for eachscheduler (schedulers[i]), and the loop ends in step 1005. In step 1003,it is determined if this resource is managed by the scheduler (shown as“resIDscheduler[i].res?” in FIG. 10). If not (step 1003=No), the method1090 continues in step 1005. If so (step 1003 =Yes), step 1004 isperformed and the handleEvent method of a model transformer and adapteris used to send a “suspend event” for this resource to the scheduler.Pseudocode for informing a scheduler is written as the following in step1004: schedulers[i].modelTransformer. handleEvent (“suspend”, resID,duration, flag). In step 1006, a zero (e.g., successful) or one (e.g.,unsuccessful) is returned to a requestor if the suspend resource wassuccessful or was not successful, respectively. Method 1090 ends afterstep 1006.

With reference to FIG. 11, a method 1190 for resuming a resource isillustrated in accordance with an exemplary embodiment of the presentinvention. The method 190 shown in FIG. 11 may be illustratively namedas PEMC.resumeResource (wfs, wfRresID). The input parameters specify theWFMS and the workflow resource ID. This method is intended to allow aresource to inform the scheduler of his or her availability after anunscheduled period of unavailability.

The first step (step 1100) is to match the WFMS specified with one thatis supported, e.g., determining a wfSystems[i] for a specified workflowsystem, wfs. In step 1101, the appropriate resource ID, resID, isobtained for the specified workflow resource ID, wfResID. Step 1102begins a loop performed for each scheduler, schedulers[i], and the loopends in step 1105. For each scheduler in steps 1102-1105, if thisresource is managed by the scheduler (step 1103, written in pseudocodeas “resID scheduler[i].res?”), the handleEvent method of the modeltransformer and adapter is used to send a “resume event” for thisresource to the scheduler in step 1104. Informing the scheduler inpseudocode is written as the following:schedulers[i].modelTransformer.handleEvent (“suspend”, resID, duration,flag). In step 1106, a zero (e.g., successful) or one (e.g.,unsuccessful) is returned to a requestor if the resume resource wassuccessful or was not successful, respectively. Method 1190 ends afterstep 1106.

Turning now to FIG. 12, a method 1290 for updating impact for a processinstance is illustrated in accordance with an exemplary embodiment ofthe present invention. The method 1290 of FIG. 12 may be illustrativelynamed PEMC.updateImpact (wfs, piID, impact). The input parametersspecify the WFMS, the process instance ID, and the business impact.Method 1190 allows the association of a business impact with a processinstance not started by the ProcessExecutionManagerController 705, theupdate of a business impact for any process instance, or both.

The method 1290 begins in step 1200, when the WFMS ID, wfs, is matchedwith one of those supported, e.g., determining wfSystems[i] forspecified WFMS, wfs. In step 1201, a unique job ID, jobID, assigned tothis process instance is determined based on the wfs and reqID. Thebusiness impact and job ID are stored in step 1202 in a store (e.g.,store 511 of FIG. 5). Step 1203 begins a loop for each scheduler,sch[i], and the loop ends in step 1207. Thus, for each scheduler insteps 1203-1207, check if this job is being managed by the scheduler instep 1204 (in pseudocode, “jobID in schedulers[i].jobs?”). If the job isnot being managed by the scheduler (step 1204=No), select anotherscheduler (step 1207). If the job is being managed by the scheduler(step 1204=Yes), then update the information (e.g., including businessimpact) in the list of schedulers (e.g., schedulers[i]jobs) for thatscheduler in step 1205. In step 1206, the updateImpact method of themodel transformer is performed to inform that scheduler of the updatevia the scheduling system adapter, shown in pseudocode as“schedulers[i].modelTransformer.updateImpact (jobID, impact)”. In step1208, a zero (e.g., successful) or one (e.g., unsuccessful) is returnedto a requestor if the update to the business impact was successful orwas not successful, respectively. Method 1290 ends after step 1208.

With reference to FIG. 13, a method 1390 for starting a process instanceis illustrated in accordance with an exemplary embodiment of the presentinvention. The method 1390 shown in FIG. 13 may be illustratively namedin pseudocode as PEMC.startProcessInstance (wfs, pID, input, impact).The input parameters specify the WFMS, the process ID, the input for theprocess, and a business impact. Method 1390 is used to request that theProcessExecutionManagerController 705 start an instance of a specifiedprocess with given input and associate a business impact with thatprocess instance.

The first step (step 1300) in method 1390 is to match the WFMS specifiedwith of those supported, which is a step of determining a wfSystems[i]for a specified WFMS, wfs. In step 1301, it is determined which classprepares the input for the execution of the process (e.g., defined bythe pID) and the class (e.g., prep) is loaded, if necessary. In step1302, the class is invoked with the specified input to prepare the inputfor the workflow system execution. In pseudocode, this is shown aspi_input=wfSystems[i].adapter.prep (input).

In step 1303, a unique process instance ID, piID is created for theprocess ID, pID. In step 1304, a unique job ID, jobID, is also createdfor the process ID. In step 1305, information (e.g., wfs, pID, piID,jobID, input, impact) is recorded about this process instance in a storesuch as store 511 of FIG. 5. The next step (step 1306) is to invoke thestartProcessInstance method of the workflow adapter to start the processinstance with the prepared input data. In pseudocode, this iswfSystems[i].adapter.startProcessInstance (pID, pi_input, piID). Next,the store (e.g., store 511 in FIG. 5) is updated with a status of“started” for this process instance (defined by wfs and piID). Theprocess instance ID is returned to the requester in step 1308 if thestarting of the process instance was successful. If the starting of theprocess instance was not successful, “FAILURE” is returned to therequester in step 1308.

With reference to FIG. 14, a method 1490 for canceling a processinstance is illustrated in accordance with an exemplary embodiment ofthe present invention. The method 1490 may be illustratively named inpseudocode as PEMC.cancelProcessInstance (wfs, piID). The inputparameters specify the WFMS and a unique process instance ID. Method1490 is used to request that the ProcessExecutionManagerController 705cancel the specified process instance (e.g., defined by the piID) in thespecified workflow system (e.g., defined by wfs).

The first step (step 1400) in method 1490 is to match the WFMS specifiedwith of those supported WFMSs, which is a step of determining awfSystems[i] for a specified WFMS, wfs. In step 1401, acancelProcessInstance method is used for the workflow adapter for thespecified WFMS. In pseudocode, this may be written aswfSystems[i].adapter.cancelProcessInstance (piID). In step 1402, a store(e.g., store 511) is updated for the specified process instance ID(e.g., piID) in the specified workflow with a status of “cancelled.” Instep 1403, a zero (e.g., successful) or one (e.g., unsuccessful) isreturned to a requestor if the canceling of the process instance wassuccessful or was not successful, respectively. Method 1490 ends afterstep 1403.

Turning now to FIG. 15, a method 1590 for suspending an activityinstance is illustrated in accordance with an exemplary embodiment ofthe present invention. The method 1590 may be illustratively named inpseudocode as PEMC.suspendActivityInstance (wfs, piID, actID). The inputparameters specify the WFMS, a unique process instance ID, and anactivity ID. Method 1590 is used to request that theProcessExecutionManagerController 705 suspend the specified activityinstance (e.g., defined by the piID and the actID) in the specified WFMS(e.g., defined by wfs).

The first step (step 1500) in method 1590 is to match the WFMS specifiedwith one of those supported WFMSs, which is a step of determining awfSystems[i] for a specified WFMS, wfs. The next step (step 1501) is toinvoke the suspendActivityInstance (indicated as “suspendAI” in FIG. 15)method of the workflow adapter with the activity instance information.In pseudocode, this may be written aswfSystems[i].adapter.suspendActivityInstance (piId, actID, flag). Instep 1502, a zero (e.g., successful) or one (e.g., unsuccessful) isreturned to a requestor if suspension of the activity instance wassuccessful or not. Method 1590 ends after step 1502.

With reference to FIG. 16, a method 1690 for resuming an activityinstance is illustrated in accordance with an exemplary embodiment ofthe present invention. The method 1690 may be illustratively named inpseudocode as PEMC.resumeActivityInstance (wfs, piID, actID). The inputparameters specify the WFMS, a unique process instance ID, and anactivity ID. Method 1690 is used to request that theProcessExecutionManagerController 705 resume the specified activityinstance (e.g., defined by the piID and the actID) in the specified WFMS(e.g., defined by the wfs).

In step 1600, the specified WFMS is matched with one of those WFMSssupported, which is a step of determining a wfSystems[i] for a specifiedWFMS, wfs. In step 1601, a check is made to see if the activity isactually suspended. If not (step 1601=No), an error (e.g., a zero) isreturned to the requestor in step 1603. Otherwise (step 1601=Yes), aresumeActivityInstance method (indicated as “resumeAI” in FIG. 16) of aworkflow adapter is invoked with the information about the activityinstance. This occurs in step 1602 and may be written in pseudocode aswfSystem.adapter.resumeActivityInstance (piId, actID). In step 1603, azero (e.g., successful) or one (e.g., unsuccessful) is returned to arequestor if resumption of the process instance was successful or wasnot successful, respectively. Method 1690 ends after step 1603.

Turning now to FIG. 17, a method 1790 for querying a process instance isillustrated in accordance with an exemplary embodiment of the presentinvention. The method 1790 may be illustratively named in pseudocode asPEMC.query (wfs, piID). The input parameters specify the WFMS and aunique process instance ID. Method 1790 is used to query theProcessExecutionManagerController 705 for the current status of thespecified process instance in the specified WFMS.

In step 1700, a job ID is determined for the specified WFMS (e.g.,defined by wfs) and process instance ID. Step 1701 begins a loop thatexamines each scheduler (scheduler[i]) and that ends in step 1704. Thus,for each scheduler, check if the jobID corresponds to one of the managedjobs (schedulers[i].jobs) in step 1702. If yes (step 1702=Yes), thestate is returned for this job in step 1703 and the method 1790 ends. Ifthe process instance is not one of the active jobs (step 1702=No),continue loop 1701-1704 checking other schedulers. If all schedulers arechecked and the job is not found in any of them, then look up status ofthe job in the store (e.g., store 511 of FIG. 5) in step 1705. The stateof the job found in the store or an error if the job was not found inthe store is returned (step 1706) to the requestor. Method 1790 endsafter step 1706.

With reference to FIG. 18, a method 1890 for restarting a scheduler isillustrated in accordance with an exemplary embodiment of the presentinvention. The method 1890 may be illustratively named in pseudocode asPEMC.restartScheduler (sch). The input parameter specifies thescheduler. Method 1890 is used by a scheduling system (e.g., schedulers709) to request that the ProcessExecutionManagerController 705 send allthe information (e.g., information on jobs and resources) required bythe scheduler to reinitialize.

The first step (step 1800) in method 1890 is to match the WFMS specifiedwith one of those supported WFMSs, which is a step of determining awfSystems[i] for a specified WFMS, wfs. In step 1801, the init method ofthe scheduler model transformer and adapter is invoked and passed therequired information. In pseudocode, this may be written asschedulers[i].modelTransformer.init (schedulers[i] jobs,schedulers[i].res, commonalities, simultaneities, overrides). In step1802, a zero (e.g., successful) or one (e.g., unsuccessful) is returnedto the requester if starting of the scheduler, sch, was successful orwas not successful, respectively. Method 1890 ends after step 1802.

With reference to FIG. 19, a method 1990 for querying resourceinformation is illustrated in accordance with an exemplary embodiment ofthe present invention. The method 1990 may be illustratively named inpseudocode as PEMC.queryResources (res[]) : res[]. The input parameterspecifies one or more resources. Method 1990 is used by a schedulingsystem (e.g., schedulers 709) to request that theProcessExecutionManagerController 705 obtain information on specifiedresources. Step 1900 begins a loop performed for each resource (e.g.,res[i]) and that ends in step 1902. For each of the specified resources,the ProcessExecutionManagerController 705 invokes the queryResourcemethod of the associated resource manager adapter in step 1901. Inpseudocode, this may be written as res[i].rm.adapter.queryResources(res[i]). The results are returned to the requestor in step 1903 andmethod 1990 ends after step 1903.

Turning to FIG. 20, a method 2090 for performing starting a task isillustrated in accordance with an exemplary embodiment of the presentinvention. The method 2090 may be illustratively named in pseudocode asPEMC.startTask (jobID, taskID, res[], preempt). The input parametersspecify the job ID, the task ID, one or more resources, and a parameterindicating whether or not current assignments should be preempted.Method 2090 is used by a scheduling system (e.g., schedulers 709) torequest that the ProcessExecutionManagerController 705 assign thespecified one or more resources to the specified process activityinstance (optionally, preempting previous assignments).

The first step is to match the scheduling system with one of thosesupported and get the process instance ID and activity instance ID forthe specified job ID and task ID. This occurs in step 2000. The nextstep is to convert the resource ID or resource IDs used by the schedulerto those used by the WFMS, wfResID[], which occurs in step 2001. In step2002, the ProcessExecutionManagerController 705 invokes astartActivityInstance method (indicated as “startAI” in FIG. 20) of theassociated workflow system adapter to start the activity. This may bewritten in pseudocode as wfSys[i].adapter.startActivityInstance (piID,actID, wfRresID[], preempt). In step 2003, a zero (e.g., successful) orone (e.g., unsuccessful) is returned to the requestor if the one or moreresources were or were not assigned, respectively, to the activityinstance for the process. Method 2090 ends after step 2003.

With reference to FIG. 21, a method 2190 for updating resourceinformation is illustrated in accordance with an illustrative embodimentof the present invention. The method 2190 may be illustratively named inpseudocode as PEMC.updateResources (res[]). The input parameterspecifies one or more resources to be updated. Method 2090 is used by ascheduling system (e.g., scheduler 709) to send resource updateinformation that the ProcessExecutionManagerController 705 obtains onthe specified one or more resources.

Step 2100 begins a loop performed for each resource, res[i], and theloop ends in step 2102. For each of the specified resources, in step2101, the ProcessExecutionManagerController 705 invokes theupdateResource method of the associated resource manager adapter withthe resource information. In pseudocode, this may be written asres[i].rm.adapter.updateResources (res[i]). In step 2103, a zero (e.g.,successful) or one (e.g., unsuccessful) is returned to the requestor ifupdating the resources was successful or was not successful,respectively. Method 2190 ends after step 2103.

With reference to FIG. 22, a method 2290 for performing a refreshresources request is illustrated in accordance with an exemplaryembodiment of the present invention. The method 2290 may beillustratively named in pseudocode as PEMC.refreshResources (rm, res[],all). The input parameters specify the resource manager to use, one ormore resources to be refreshed, and a value indicating whether or notall resources are being refreshed. Method 2290 is used by a resourcemanager (e.g., resManager 707) to refresh resource information.

The first step (step 2200) is to match the resource manager (e.g., rm)with one of those resource managers that are supported (e.g.,resManagers[i]). Step 2201 starts a loop performed for each scheduler(e.g., schedulers[i]), and this loop ends in step 2217. Thus, for eachof the schedulers, steps 2201-2217 are performed. In step 2202, an emptylist (saveRes) of resources is created. Step 2203 starts a loopperformed for each resource, res[j], and the loop ends in step 2206. Instep 2204, it is determined if the resources are managed by thisscheduler, in pseudocode this may be written as“res[j].scheduler=schedulers[i]?”. If not (step 2204=No), the loop2203-2206 continue with the next resource, if any. If yes (step2204=Yes), the resource is added to the list saveRes.

In step 2207, it is checked if all resources are being refreshed. If yes(step 2207=Yes), then delete all resources for this resource manager inthis schedulers list of resources in step 2214. In pseudocode, this maybe written as delete all resources in schedulers[i].res, whereschedulers[i].rm=rm. Then, add the new resource information to thescheduler in step 2215. In pseudocode, step 2215 can be written as “addsaveRes to schedulers[i].res.” Finally, in step 2216, therefreshResources method of the associated scheduling system modeltransformer and adapter is invoked with the list of resources for thisscheduler and a value of TRUE. In pseudocode, this may be written asschedulers[i].modelTransformer.refreshResources (schedulers[i].res,TRUE).

If no in step 2207, then step 2208 starts a loop performed for eachresource managed by this scheduler, and the loop ends in step 2212. Instep 2209, it is determined if this resource is already in the list ofresources managed by this scheduler. In pseudocode, this can be writtenas saveRes[i] in schedulers[i].res. If it is (step 2209=Yes), then theresource information is updated in step 2211. Otherwise (step 2209=No),add the resource information to the list kept by the scheduler in step2210. Finally, in step 2213, the refreshResources method of theassociated scheduling system model transformer and adapter is invokedwith the list of resources for this scheduler and a value of FALSE. Inpseudocode, this may be written asschedulers[i].adapter.refreshResources (schedulers[i].saveRes, FALSE).

Once steps 2201-2217 have been completed for all schedulers supported,the resource map (e.g., resMap 711) for all the resources isregenerated. This occurs in step 2218. In step 2219, a zero (e.g.,successful) or one (e.g., unsuccessful) is returned to the resourcerefresh did complete or did not complete, respectively. Method 2290 endsafter step 2219.

With reference to FIG. 23, a method 2390 for requesting to override aschedule is illustrated in accordance with an exemplary embodiment ofthe present invention. The method 2390 may be illustratively named inpseudocode as overrideSchedule (sch, override[]). The input parametersspecify a scheduler and one or more overrides. Method 2390 is used by aresource manager (e.g., resManagers 707) to request that theProcessExecutionManagerController 705 override resource assignment orresource assignments made by the scheduler.

The first step (step 2300) is to match the scheduling system, sch, withone of a number of supported schedulers, schedulers[i]. The next step(step 2301) is to record the override information in a store such asstore 514 in FIG. 5. In step 2302, the ProcessExecutionManagerController705 invokes the overrideSchedule method of the associated schedulingsystem model transformer and adapter with the override information. Inpseudocode, this may be written asschedulers[i].modelTransformer.overrideSchedule (override). Method 2390ends after step 2302.

Turning now to FIG. 24, a method 2490 for requesting handling of anevent is illustrated in accordance with an illustrative embodiment ofthe present invention. The method 2490 may be illustratively named inpseudocode as wfSystems[i].adapter.mon.handleEvent (wfEvent). The inputparameter specifies an event to be handled. Method 2490 is used by aWFMS (illustratively, a workflow adapter) to inform the appropriatemonitor in ProcessExecutionManagerController 705 of progress in theexecution of process instances.

The first step (2400) is to determine the job ID, jobID, correspondingto the specified process instance ID, wfEvent.piID. Step 2401 begins aloop performed for each scheduler, sch[i], and the loop ends in step2405. Steps 2401-2405 are therefore performed for each scheduler. Instep 2402, it is determined if this job, jobID, is being scheduled bythis scheduler. In pseudocode, this may be written as “jobID inschedulers[i] jobs?”.

If yes (step 2402=Yes), the status is updated in step 2403 (e.g.,schedulers[i]jobs(jobID)=wfEvent.status). In step 2404, the handleEventmethod of the appropriate scheduler model transformer and adapter isinvoked with the details of the event. This may be written in pseudocodeas the following: schedulers[i].modelTransformer.handleEvent (wfEvent).If step 2402 is No, another scheduler is selected in step 2405 and themethod 2490 continues in step 2402.

Once all schedulers have been examined, in step 2405 it is determined ifthe event indicated the end of a process instance. If not (step2406=No), the method 2490 ends. If so (step 2406=Yes), a store such asstore 511 in FIG. 5 would be updated with the status (e.g., “complete”)of this process instance (defined by, e.g., piID) in step 2407. In step2408, it is determined if the ProcessExecutionManagerController 705(e.g., PEMC) initiated this process instance. If yes (step 2408=Yes), instep 2409, the requester is informed of the end of the process instanceand any output, if necessary, is communicated to the requester. If not(step 2408=No), method 2490 ends.

It is to be understood that the embodiments and variations shown anddescribed herein are merely illustrative of the principles of thisinvention and that various modifications may be implemented by thoseskilled in the art without departing from the scope and spirit of theinvention.

1. A method for managing execution of processes on a data processingsystem, the data processing system comprising one or more processinstances that are each an execution of a corresponding process, eachprocess instance comprising one or more activity instances, the methodcomprising the steps of: determining one or more business impacts forthe one or more process instances, the one or more activity instances,or both the one or more process instances and the one or more activityinstances; and managing order of execution of the activity instances byallocating resources to activity instances in order to achieve anobjective defined in terms of the one or more business impacts.
 2. Themethod of claim 1, further comprising the steps of: receiving one ormore requests for execution of one or more processes; and for a givenone of the one or more requests, performing one or more of assigning,updating, aggregating, and weighting of one or more first businessimpacts associated with the given request to create one or more secondbusiness impacts associated with the given request, the given requestfor execution of a given process; and modifying a given request tocreate a modified request, the modified request for execution of thegiven process or another process; and wherein the step of managingfurther comprises the step of managing unmodified requests and anymodified requests.
 3. The method of claim 2, wherein the step ofperforming further comprises the step of performing in a manner so as toimprove cost and efficiency of execution of the process instances one ormore of assigning, updating, aggregating, and weighting of the one ormore first business impacts associated with the given request to createthe one or more second business impacts associated with the givenrequest, the cost and efficiency determined by one or more criteria setby an organization.
 4. The method of claim 1, wherein: the one or moreprocess instances comprises a plurality of process instances; and thedata processing system comprises one or more Workflow Management Systems(WFMSs), each WFMS comprising at least one of the plurality of processinstances.
 5. The method of claim 1, wherein a given activity instancecorresponds to an activity, the activity instance to be executed by anorganization that controls a resource that is to perform the activitybut wherein the organization does not control the data processingsystem.
 6. The method of claim 1, wherein a given process in the dataprocessing system ranges from simple task lists to complex task graphs.7. The method of claim 1, wherein a given process in the data processingsystem can be fully automated or partially automated.
 8. The method ofclaim 1, wherein: the one or more activity instances and the relativeorder of execution of some of the one or more activity instances withina process instance are described by one or more workflow process models;and the step of managing further comprises the step of managing order ofexecution of activity instances by allocating resources to activityinstances in order to achieve the while satisfying one or moreconstraints of the one or more workflow process models as well asoverrides from one or more resource managers.
 9. The method of claim 1,wherein a given activity instance to be performed may require zero, one,or more resources.
 10. The method of claim 1, wherein a given one of theone or more business impacts comprises one or more of a simple priority,a utility function, a step function, and a cost function over time. 11.The method of claim 1, wherein the objective is defined by an objectivefunction or a pointer to the objective function.
 12. The method of claim1, wherein a resource comprises but is not limited to one of thefollowing: a person, a software agent, hardware, a license, or acombination thereof.
 13. A data processing system for managing executionof processes, the data processing system comprising: a memory thatstores computer-readable code, one or more process instances, and one ormore activity instances, wherein the one or more process instances areeach an execution of a corresponding process, each process instancecomprising one or more activity instances; and a processor operativelycoupled to said memory, said processor configured to implement saidcomputer-readable code, said computer-readable code configured toperform the steps of: determining one or more business impacts for theone or more process instances, the one or more activity instances, orboth the one or more process instances and the one or more activityinstances; and managing order of execution of the activity instances byallocating resources to activity instances in order to achieve anobjective defined in terms of the one or more business impacts.
 14. Amethod for managing requests for execution of one or more processes on adata processing system, the method comprising the steps of: receivingone or more requests for the execution of the one or more processes; fora given one of the one or more requests, performing one or more ofassigning, updating, aggregating, and weighting of one or more firstbusiness impacts associated with the given request to create one or moresecond business impacts associated with the given request, the givenrequest for execution of a given process; modifying a given request tocreate a modified request, the modified request for execution of thegiven process or another process; and managing unmodified requests andany modified requests in order to execute processes corresponding to theunmodified and modified requests.
 15. The method of claim 14, wherein:the data processing system further comprises one or more processinstances that are each an execution of a corresponding process, eachprocess instance comprising one or more activity instances; and the stepof managing further comprises the step of managing order of execution ofthe activity instances by allocating resources to activity instances inorder to achieve an objective defined in terms of the one or more secondbusiness impacts.
 16. The method of claim 14, wherein the method furthercomprises the step of determining, using one or more predeterminedcriteria, that a goal of the given process is the same as a goal of afirst process corresponding to a first request; and the step ofmodifying further comprises the step of altering the given request tothe modified request, the modified request for execution of the firstprocess.
 17. The method of claim 16, wherein the step of performingfurther comprises the step of performing one or more of assigning,updating, aggregating, and weighting of one or more first businessimpacts associated with the given request to create the one or moresecond business impacts; and the step of modifying further comprises thestep of associating the one or more second business impacts with themodified request.
 18. The method of claim 14, wherein: the step ofperforming further comprises the step of performing one or more ofassigning, updating, aggregating, and weighting of one or more firstbusiness impacts associated with the given request to create one or moresecond business impacts associated with the given request, wherein theassigning operation assigns one or more default business impactsassociated with the given request to create the one or more secondbusiness impacts.
 19. The method of claim 14, wherein: the methodfurther comprises the steps of: receiving the given request and at leastone additional request; and determining, using one or more procedures,that the given request and the at least one additional request arerelated; and the step of modifying further comprises the step ofcombining the related requests into the modified request.
 20. The methodof claim 19, wherein a given one of the one or more procedures isdefined by an organization.
 21. The method of claim 19, wherein each ofthe given request and the at least another request each comprises arequest for execution of the given process.
 22. The method of claim 19,wherein: the step of performing further comprises the step of performingone or more of assigning, updating, aggregating, and weighting of one ormore first business impacts associated with the given request and the atleast one additional request to create one or more second businessimpacts associated with the given request; and the step of combining therelated requests further comprises the step of associated the one ormore second business impacts with the modified request.
 23. A dataprocessing system for managing requests for execution of one or moreprocesses, the system comprising: a memory that stores computer-readablecode; and a processor operatively coupled to said memory, said processorconfigured to implement said computer-readable code, saidcomputer-readable code configured to perform the steps of: receiving oneor more requests for the execution of the one or more processes; for agiven one of the one or more requests, performing one or more ofassigning, updating, aggregating, and weighting of one or more firstbusiness impacts associated with the given request to create one or moresecond business impacts associated with the given request, the givenrequest for execution of a given process; modifying a given request tocreate a modified request, the modified request for execution of thegiven process or another process; and managing unmodified requests andany modified requests in order to execute processes corresponding to theunmodified and modified requests.